package com.runen.infinitemovement.track;

import android.content.Context;

import com.amap.api.location.AMapLocationClient;
import com.amap.api.location.AMapLocationClientOption;
import com.amap.api.location.AMapLocationListener;
import com.runen.rxnetlibrary.utils.StringUtil;

/**
 * Create by LiaoDuanHong
 * Create date ${date}
 */
public class LocationUtil {
    private Context context;
    //声明AMapLocationClient类对象
    public AMapLocationClient mLocationClient = null;
    //声明定位回调监听器
    public AMapLocationListener mLocationListener = null;
    // 地球半径
    private final static double EARTH_RADIUS = 6378.137;

    public LocationUtil(Context context) {
        this.context = context;
        //初始化定位
        mLocationClient = new AMapLocationClient(context.getApplicationContext());
        //声明AMapLocationClientOption对象
        AMapLocationClientOption mLocationOption = initLocationClientOption();
        //给定位客户端对象设置定位参数
        mLocationClient.setLocationOption(mLocationOption);
    }


    private AMapLocationClientOption initLocationClientOption() {
        AMapLocationClientOption option = new AMapLocationClientOption();
        // 设置定位场景，目前支持三种场景（签到、出行、运动，默认无场景）
        option.setLocationPurpose(AMapLocationClientOption.AMapLocationPurpose.Transport);
        //设置定位模式为AMapLocationMode.Hight_Accuracy，高精度模式。
        option.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);
        //设置定位模式为AMapLocationMode.Battery_Saving，低功耗模式。
        //option.setLocationMode(AMapLocationClientOption.AMapLocationMode.Battery_Saving);
        //设置定位模式为AMapLocationMode.Device_Sensors，仅设备模式。
        //option.setLocationMode(AMapLocationClientOption.AMapLocationMode.Device_Sensors);

        //获取一次定位结果：
        //该方法默认为false。
        option.setOnceLocation(false);
//        获取最近3s内精度最高的一次定位结果：
        //设置setOnceLocationLatest(boolean b)接口为true，启动定位时SDK会返回最近3s内精度最高的一次定位结果。
        // 如果设置其为true，setOnceLocation(boolean b)接口也会被设置为true，反之不会，默认为false。
//        option.setOnceLocationLatest(true);
//        设置定位间隔,单位毫秒,默认为2000ms，最低1000ms。
        option.setInterval(1000);
        //设置是否返回地址信息（默认返回地址信息）
        option.setNeedAddress(true);
        //设置是否允许模拟位置,默认为true，允许模拟位置
        option.setMockEnable(true);
        //单位是毫秒，默认30000毫秒，建议超时时间不要低于8000毫秒。
        option.setHttpTimeOut(20000);
        //关闭缓存机制
        option.setLocationCacheEnable(false);
        return option;
    }

    /**
     * 注册定位回调
     *
     * @param listener
     */
    public void registerLocationListener(AMapLocationListener listener) {
        mLocationListener = listener;
        if (mLocationListener != null) {
            mLocationClient.setLocationListener(mLocationListener);
        }
    }

    /**
     * 启动定位
     */
    public void start() {
        mLocationClient.startLocation();
    }

    /**
     * 重新定位
     */
    public void reStart() {
        if (mLocationClient.isStarted()) {
            return;
        }
        mLocationClient.startLocation();
    }

    /**
     * 停止定位
     */
    public void stop() {
            mLocationClient.stopLocation();
    }

    /**
     * 销毁定位
     */
    public void destroy() {
        if (mLocationClient != null) {
            mLocationClient.unRegisterLocationListener(mLocationListener);
            mLocationClient.onDestroy();
            mLocationClient = null;
        }
    }

    private static double rad(double d) {
        return d * Math.PI / 180.0;
    }

    /**
     * 计算距离 返回单位km
     *
     * @param lat1
     * @param lng1
     * @param lat2
     * @param lng2
     * @return
     */
    public double getDistance(double lat1, double lng1, double lat2,
                              double lng2) {
        double radLat1 = rad(lat1);
        double radLat2 = rad(lat2);
        // 如果有一方等于零，直接返回0
        if (radLat1 == 0 || radLat2 == 0) {
            return 0;
        }
        double a = radLat1 - radLat2;
        double b = rad(lng1) - rad(lng2);
        double s = 2 * Math.asin(Math.sqrt(Math.pow(Math.sin(a / 2), 2)
                + Math.cos(radLat1) * Math.cos(radLat2)
                * Math.pow(Math.sin(b / 2), 2)));
        s = s * EARTH_RADIUS;
        s = Math.round(s * 10000) / 10000;
        return s;
    }

    /**
     * 距离格式化
     *
     * @param distance 以千米为单位
     * @return
     */
    public String distanceKMFormat(double distance) {
        return distance > 1 ? (distance + "KM") : (distance * 1000 + "M");
    }


    /**
     * 距离只保留两位小数
     *
     * @param distance 以米为单位
     * @return
     */
    public String distanceFormat(double distance) {
        String str;
        double value = distance;
        if (distance >= 1000) {
            value = value / 1000;
            str = "KM";
        } else {
            str = "M";
        }
        return String.format("%s%s", StringUtil.formatMoney(value), str);
    }
}
